home *** CD-ROM | disk | FTP | other *** search
/ Champak 62 / Volume 62 - JOGO DISK .iso / Games / poink.swf / scripts / DefineButton2_156 / BUTTONCONDACTION on(press).as next >
Text File  |  2008-03-17  |  62KB  |  1,114 lines

  1. on(press){
  2.    var ┬º\x01┬º = 403;
  3.    loop0:
  4.    while(true)
  5.    {
  6.       if(eval("\x01") == 403)
  7.       {
  8.          set("\x01",eval("\x01") + 165);
  9.          ┬º┬ºpush(true);
  10.          continue;
  11.       }
  12.       if(eval("\x01") == 568)
  13.       {
  14.          set("\x01",eval("\x01") + 336);
  15.          if(┬º┬ºpop())
  16.          {
  17.             set("\x01",eval("\x01") - 674);
  18.          }
  19.          continue;
  20.       }
  21.       if(eval("\x01") == 666)
  22.       {
  23.          set("\x01",eval("\x01") + 13);
  24.          while(true)
  25.          {
  26.             set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  27.             if(┬º┬ºpop())
  28.             {
  29.                set("\x01",eval("\x01") + 289);
  30.             }
  31.             loop2:
  32.             while(true)
  33.             {
  34.                if(eval("\x01") == 632)
  35.                {
  36.                   set("\x01",eval("\x01") + 260);
  37.                   ┬º┬ºpush(true);
  38.                   continue;
  39.                }
  40.                if(eval("\x01") == 587)
  41.                {
  42.                   set("\x01",eval("\x01") + 241);
  43.                   prevFrame();
  44.                   prevFrame();
  45.                   break loop0;
  46.                }
  47.                if(eval("\x01") == 551)
  48.                {
  49.                   set("\x01",eval("\x01") + 361);
  50.                   break loop0;
  51.                }
  52.                if(eval("\x01") == 813)
  53.                {
  54.                   set("\x01",eval("\x01") + 143);
  55.                   ┬º┬ºpush(true);
  56.                   continue;
  57.                }
  58.                if(eval("\x01") == 637)
  59.                {
  60.                   set("\x01",eval("\x01") + 50);
  61.                   ┬º┬ºpush(true);
  62.                   continue;
  63.                }
  64.                if(eval("\x01") == 811)
  65.                {
  66.                   set("\x01",eval("\x01") - 545);
  67.                   ┬º┬ºpush(┬º┬ºpop()());
  68.                   break loop0;
  69.                }
  70.                if(eval("\x01") == 859)
  71.                {
  72.                   set("\x01",eval("\x01") - 619);
  73.                   break loop0;
  74.                }
  75.                if(eval("\x01") == 266)
  76.                {
  77.                   set("\x01",eval("\x01") - 165);
  78.                   ┬º┬ºpush(true);
  79.                   continue;
  80.                }
  81.                if(eval("\x01") == 687)
  82.                {
  83.                   break;
  84.                }
  85.                if(eval("\x01") == 956)
  86.                {
  87.                   set("\x01",eval("\x01") - 145);
  88.                   if(┬º┬ºpop())
  89.                   {
  90.                      set("\x01",eval("\x01") - 545);
  91.                   }
  92.                   continue;
  93.                }
  94.                if(eval("\x01") == 642)
  95.                {
  96.                   addr2315:
  97.                   ┬º┬ºpush("\x01");
  98.                   ┬º┬ºpush(eval("\x01") + 289);
  99.                   while(true)
  100.                   {
  101.                      set(┬º┬ºpop(),┬º┬ºpop());
  102.                      set(┬º┬ºpop(),eval(┬º┬ºpop()) - 345);
  103.                      ┬º┬ºpush(true);
  104.                      loop3:
  105.                      while(eval("\x01") != 213)
  106.                      {
  107.                         if(eval("\x01") != 201)
  108.                         {
  109.                            if(eval("\x01") != 551)
  110.                            {
  111.                               if(eval("\x01") != 569)
  112.                               {
  113.                                  if(eval("\x01") != 908)
  114.                                  {
  115.                                     if(eval("\x01") != 878)
  116.                                     {
  117.                                        if(eval("\x01") != 533)
  118.                                        {
  119.                                           if(eval("\x01") != 563)
  120.                                           {
  121.                                              if(eval("\x01") != 992)
  122.                                              {
  123.                                                 if(eval("\x01") != 77)
  124.                                                 {
  125.                                                    if(eval("\x01") != 909)
  126.                                                    {
  127.                                                       if(eval("\x01") == 767)
  128.                                                       {
  129.                                                          set("\x01",eval("\x01") + 128);
  130.                                                          if(┬º┬ºpop())
  131.                                                          {
  132.                                                             set("\x01",eval("\x01") - 702);
  133.                                                          }
  134.                                                       }
  135.                                                       else if(eval("\x01") == 954)
  136.                                                       {
  137.                                                          set("\x01",eval("\x01") - 602);
  138.                                                          if(┬º┬ºpop())
  139.                                                          {
  140.                                                             set("\x01",eval("\x01") - 299);
  141.                                                          }
  142.                                                       }
  143.                                                       else
  144.                                                       {
  145.                                                          if(eval("\x01") == 895)
  146.                                                          {
  147.                                                             set("\x01",eval("\x01") - 702);
  148.                                                             return ┬º┬ºpop() + (┬º┬ºpop() ^ ┬º┬ºpop());
  149.                                                          }
  150.                                                          if(eval("\x01") == 599)
  151.                                                          {
  152.                                                             set("\x01",eval("\x01") - 30);
  153.                                                             gotoAndStop("E∩┐╜ ∩┐╜\x06\x10");
  154.                                                             break loop0;
  155.                                                          }
  156.                                                          if(eval("\x01") == 193)
  157.                                                          {
  158.                                                             set("\x01",eval("\x01") + 340);
  159.                                                             ┬º┬ºpush(true);
  160.                                                          }
  161.                                                          else
  162.                                                          {
  163.                                                             if(eval("\x01") == 352)
  164.                                                             {
  165.                                                                set("\x01",eval("\x01") - 299);
  166.                                                                toggleHighQuality();
  167.                                                                if(┬º┬ºpop()[┬º┬ºpop()[[]]]._parent && !_x.g._y)
  168.                                                                {
  169.                                                                   setProperty("bx", _X, _x.g.stg);
  170.                                                                   setProperty("bx", _Y, _x.g.by);
  171.                                                                   set(┬º┬ºconstant(8),_x.g.stg - _x.g[┬º┬ºconstant(9)]);
  172.                                                                   set(┬º┬ºconstant(10),_x.g.by - _x.g[┬º┬ºconstant(11)]);
  173.                                                                   setProperty("bx", _rotation, (- eval(┬º┬ºconstant(12))[┬º┬ºconstant(13)](eval(┬º┬ºconstant(8)),eval(┬º┬ºconstant(10)))) / 0.017453292519943295);
  174.                                                                   set(┬º┬ºconstant(14),getProperty("bx", _X) - _x.g[┬º┬ºconstant(9)]);
  175.                                                                   set(┬º┬ºconstant(15),getProperty("bx", _Y) - _x.g[┬º┬ºconstant(11)]);
  176.                                                                   set(┬º┬ºconstant(16),eval(┬º┬ºconstant(12))[┬º┬ºconstant(18)](eval(┬º┬ºconstant(12))[┬º┬ºconstant(17)](eval(┬º┬ºconstant(14)) * eval(┬º┬ºconstant(14)) + eval(┬º┬ºconstant(15)) * eval(┬º┬ºconstant(15)))));
  177.                                                                   if(eval(┬º┬ºconstant(16)) > 100)
  178.                                                                   {
  179.                                                                      set(┬º┬ºconstant(16),100);
  180.                                                                   }
  181.                                                                   setProperty("bx", _yscale, eval(┬º┬ºconstant(16)));
  182.                                                                }
  183.                                                                break loop0;
  184.                                                             }
  185.                                                             if(eval("\x01") != 53)
  186.                                                             {
  187.                                                                if(eval("\x01") == 762)
  188.                                                                {
  189.                                                                   set("\x01",eval("\x01") + 134);
  190.                                                                   gotoAndPlay(2);
  191.                                                                   break loop0;
  192.                                                                }
  193.                                                                break loop0;
  194.                                                             }
  195.                                                             set("\x01",eval("\x01") + 24);
  196.                                                             ┬º┬ºpush(true);
  197.                                                          }
  198.                                                       }
  199.                                                       continue;
  200.                                                    }
  201.                                                    set("\x01",eval("\x01") - 147);
  202.                                                    set(┬º┬ºpop(),┬º┬ºpop());
  203.                                                    ┬º┬ºpush(true);
  204.                                                    while(true)
  205.                                                    {
  206.                                                       if(eval("\x01") == 66)
  207.                                                       {
  208.                                                          break loop3;
  209.                                                       }
  210.                                                       if(eval("\x01") == 993)
  211.                                                       {
  212.                                                          break loop3;
  213.                                                       }
  214.                                                       if(eval("\x01") == 885)
  215.                                                       {
  216.                                                          break loop3;
  217.                                                       }
  218.                                                       if(eval("\x01") == 731)
  219.                                                       {
  220.                                                          break loop3;
  221.                                                       }
  222.                                                       if(eval("\x01") == 871)
  223.                                                       {
  224.                                                          break loop3;
  225.                                                       }
  226.                                                       if(eval("\x01") == 278)
  227.                                                       {
  228.                                                          break loop3;
  229.                                                       }
  230.                                                       if(eval("\x01") == 554)
  231.                                                       {
  232.                                                          break loop3;
  233.                                                       }
  234.                                                       if(eval("\x01") == 269)
  235.                                                       {
  236.                                                          break loop3;
  237.                                                       }
  238.                                                       if(eval("\x01") == 228)
  239.                                                       {
  240.                                                          break loop3;
  241.                                                       }
  242.                                                       if(eval("\x01") == 325)
  243.                                                       {
  244.                                                          break loop3;
  245.                                                       }
  246.                                                       if(eval("\x01") == 553)
  247.                                                       {
  248.                                                          break loop3;
  249.                                                       }
  250.                                                       if(eval("\x01") == 327)
  251.                                                       {
  252.                                                          break loop3;
  253.                                                       }
  254.                                                       if(eval("\x01") == 211)
  255.                                                       {
  256.                                                          break loop3;
  257.                                                       }
  258.                                                       if(eval("\x01") == 685)
  259.                                                       {
  260.                                                          set("\x01",eval("\x01") - 416);
  261.                                                          break loop3;
  262.                                                       }
  263.                                                       if(eval("\x01") == 868)
  264.                                                       {
  265.                                                          set("\x01",eval("\x01") - 326);
  266.                                                          loop5:
  267.                                                          while(true)
  268.                                                          {
  269.                                                             ┬º┬ºpush(true);
  270.                                                             while(true)
  271.                                                             {
  272.                                                                if(eval("\x01") == 750)
  273.                                                                {
  274.                                                                   set("\x01",eval("\x01") - 457);
  275.                                                                   ┬º┬ºpush(true);
  276.                                                                }
  277.                                                                else if(eval("\x01") == 570)
  278.                                                                {
  279.                                                                   set("\x01",eval("\x01") + 364);
  280.                                                                   ┬º┬ºpush(true);
  281.                                                                }
  282.                                                                else
  283.                                                                {
  284.                                                                   if(eval("\x01") == 482)
  285.                                                                   {
  286.                                                                      set("\x01",eval("\x01") + 241);
  287.                                                                      break loop0;
  288.                                                                   }
  289.                                                                   if(eval("\x01") == 448)
  290.                                                                   {
  291.                                                                      set("\x01",eval("\x01") + 547);
  292.                                                                      if(┬º┬ºpop())
  293.                                                                      {
  294.                                                                         set("\x01",eval("\x01") - 829);
  295.                                                                      }
  296.                                                                   }
  297.                                                                   else if(eval("\x01") == 934)
  298.                                                                   {
  299.                                                                      set("\x01",eval("\x01") - 419);
  300.                                                                      if(┬º┬ºpop())
  301.                                                                      {
  302.                                                                         set("\x01",eval("\x01") - 247);
  303.                                                                      }
  304.                                                                   }
  305.                                                                   else if(eval("\x01") == 308)
  306.                                                                   {
  307.                                                                      set("\x01",eval("\x01") - 195);
  308.                                                                      if(┬º┬ºpop())
  309.                                                                      {
  310.                                                                         set("\x01",eval("\x01") - 18);
  311.                                                                      }
  312.                                                                   }
  313.                                                                   else if(eval("\x01") == 268)
  314.                                                                   {
  315.                                                                      set("\x01",eval("\x01") + 607);
  316.                                                                      ┬º┬ºpush(true);
  317.                                                                   }
  318.                                                                   else if(eval("\x01") == 555)
  319.                                                                   {
  320.                                                                      set("\x01",eval("\x01") - 247);
  321.                                                                      ┬º┬ºpush(true);
  322.                                                                   }
  323.                                                                   else if(eval("\x01") == 875)
  324.                                                                   {
  325.                                                                      set("\x01",eval("\x01") - 606);
  326.                                                                      if(┬º┬ºpop())
  327.                                                                      {
  328.                                                                         set("\x01",eval("\x01") - 150);
  329.                                                                      }
  330.                                                                   }
  331.                                                                   else
  332.                                                                   {
  333.                                                                      if(eval("\x01") == 511)
  334.                                                                      {
  335.                                                                         break loop5;
  336.                                                                      }
  337.                                                                      if(eval("\x01") == 293)
  338.                                                                      {
  339.                                                                         set("\x01",eval("\x01") + 189);
  340.                                                                         if(┬º┬ºpop())
  341.                                                                         {
  342.                                                                            set("\x01",eval("\x01") + 241);
  343.                                                                         }
  344.                                                                      }
  345.                                                                      else
  346.                                                                      {
  347.                                                                         if(eval("\x01") == 520)
  348.                                                                         {
  349.                                                                            set("\x01",eval("\x01") + 50);
  350.                                                                            ┬º┬ºpop() or ┬º┬ºpop();
  351.                                                                         }
  352.                                                                         if(eval("\x01") == 119)
  353.                                                                         {
  354.                                                                            set("\x01",eval("\x01") + 329);
  355.                                                                            ┬º┬ºpush(true);
  356.                                                                         }
  357.                                                                         else if(eval("\x01") == 956)
  358.                                                                         {
  359.                                                                            set("\x01",eval("\x01") - 436);
  360.                                                                            if(┬º┬ºpop())
  361.                                                                            {
  362.                                                                               set("\x01",eval("\x01") + 50);
  363.                                                                            }
  364.                                                                         }
  365.                                                                         else
  366.                                                                         {
  367.                                                                            if(eval("\x01") == 723)
  368.                                                                            {
  369.                                                                               continue loop5;
  370.                                                                            }
  371.                                                                            if(eval("\x01") == 494)
  372.                                                                            {
  373.                                                                               set("\x01",eval("\x01") + 462);
  374.                                                                               ┬º┬ºpush(true);
  375.                                                                            }
  376.                                                                            else
  377.                                                                            {
  378.                                                                               if(eval("\x01") == 515)
  379.                                                                               {
  380.                                                                                  set("\x01",eval("\x01") - 247);
  381.                                                                                  with(┬º┬ºpop())
  382.                                                                                  {
  383.                                                                                  }
  384.                                                                                  break;
  385.                                                                               }
  386.                                                                               if(eval("\x01") == 215)
  387.                                                                               {
  388.                                                                                  set("\x01",eval("\x01") + 178);
  389.                                                                                  if(┬º┬ºpop())
  390.                                                                                  {
  391.                                                                                     set("\x01",eval("\x01") + 162);
  392.                                                                                  }
  393.                                                                               }
  394.                                                                               else
  395.                                                                               {
  396.                                                                                  if(eval("\x01") == 113)
  397.                                                                                  {
  398.                                                                                     set("\x01",eval("\x01") - 18);
  399.                                                                                     stop();
  400.                                                                                     ┬º┬ºpush(┬º┬ºpop() / ┬º┬ºpop());
  401.                                                                                     break loop0;
  402.                                                                                  }
  403.                                                                                  if(eval("\x01") == 289)
  404.                                                                                  {
  405.                                                                                     set("\x01",eval("\x01") - 3);
  406.                                                                                     ┬º┬ºpush(┬º┬ºpop() ^ ┬º┬ºpop());
  407.                                                                                     break loop0;
  408.                                                                                  }
  409.                                                                                  if(eval("\x01") == 393)
  410.                                                                                  {
  411.                                                                                     set("\x01",eval("\x01") + 162);
  412.                                                                                     break loop0;
  413.                                                                                  }
  414.                                                                                  if(eval("\x01") == 95)
  415.                                                                                  {
  416.                                                                                     set("\x01",eval("\x01") + 758);
  417.                                                                                     ┬º┬ºpush(true);
  418.                                                                                  }
  419.                                                                                  else if(eval("\x01") == 853)
  420.                                                                                  {
  421.                                                                                     set("\x01",eval("\x01") - 342);
  422.                                                                                     if(┬º┬ºpop())
  423.                                                                                     {
  424.                                                                                        set("\x01",eval("\x01") - 17);
  425.                                                                                     }
  426.                                                                                  }
  427.                                                                                  else if(eval("\x01") == 101)
  428.                                                                                  {
  429.                                                                                     set("\x01",eval("\x01") + 188);
  430.                                                                                     if(┬º┬ºpop())
  431.                                                                                     {
  432.                                                                                        set("\x01",eval("\x01") - 3);
  433.                                                                                     }
  434.                                                                                  }
  435.                                                                                  else
  436.                                                                                  {
  437.                                                                                     if(eval("\x01") == 269)
  438.                                                                                     {
  439.                                                                                        set("\x01",eval("\x01") - 150);
  440.                                                                                        break;
  441.                                                                                     }
  442.                                                                                     if(eval("\x01") == 995)
  443.                                                                                     {
  444.                                                                                        set("\x01",eval("\x01") - 829);
  445.                                                                                        break loop0;
  446.                                                                                     }
  447.                                                                                     if(eval("\x01") == 166)
  448.                                                                                     {
  449.                                                                                        set("\x01",eval("\x01") + 828);
  450.                                                                                        ┬º┬ºpush(true);
  451.                                                                                     }
  452.                                                                                     else if(eval("\x01") == 994)
  453.                                                                                     {
  454.                                                                                        set("\x01",eval("\x01") - 662);
  455.                                                                                        if(┬º┬ºpop())
  456.                                                                                        {
  457.                                                                                           set("\x01",eval("\x01") + 453);
  458.                                                                                        }
  459.                                                                                     }
  460.                                                                                     else
  461.                                                                                     {
  462.                                                                                        if(eval("\x01") == 332)
  463.                                                                                        {
  464.                                                                                           set("\x01",eval("\x01") + 453);
  465.                                                                                           break loop0;
  466.                                                                                        }
  467.                                                                                        if(eval("\x01") != 785)
  468.                                                                                        {
  469.                                                                                           if(eval("\x01") == 286)
  470.                                                                                           {
  471.                                                                                              set("\x01",eval("\x01") + 642);
  472.                                                                                              stop();
  473.                                                                                              _parent.mati("kena tanah");
  474.                                                                                              break loop0;
  475.                                                                                           }
  476.                                                                                           break loop0;
  477.                                                                                        }
  478.                                                                                        set("\x01",eval("\x01") - 684);
  479.                                                                                        ┬º┬ºpush(true);
  480.                                                                                     }
  481.                                                                                  }
  482.                                                                               }
  483.                                                                            }
  484.                                                                         }
  485.                                                                      }
  486.                                                                   }
  487.                                                                }
  488.                                                             }
  489.                                                             addr2601:
  490.                                                             continue loop2;
  491.                                                          }
  492.                                                          set("\x01",eval("\x01") - 17);
  493.                                                          call(┬º┬ºpop() + 1);
  494.                                                          ┬º┬ºpush(┬º┬ºpop());
  495.                                                          break loop0;
  496.                                                       }
  497.                                                       if(eval("\x01") != 542)
  498.                                                       {
  499.                                                          break loop0;
  500.                                                       }
  501.                                                       set("\x01",eval("\x01") - 264);
  502.                                                    }
  503.                                                 }
  504.                                                 break;
  505.                                              }
  506.                                              break;
  507.                                           }
  508.                                           break;
  509.                                        }
  510.                                        break;
  511.                                     }
  512.                                     break;
  513.                                  }
  514.                                  break;
  515.                               }
  516.                               break;
  517.                            }
  518.                            break;
  519.                         }
  520.                         break;
  521.                      }
  522.                      addr553:
  523.                      with(┬º┬ºpop())
  524.                      {
  525.                         loop0:
  526.                         while(true)
  527.                         {
  528.                            set(┬º┬ºpop(),eval(┬º┬ºpop()) + 2);
  529.                            ┬º┬ºpush(true);
  530.                            while(true)
  531.                            {
  532.                               if(eval("\x01") == 66)
  533.                               {
  534.                                  set("\x01",eval("\x01") + 487);
  535.                                  ┬º┬ºpush(true);
  536.                               }
  537.                               else
  538.                               {
  539.                                  if(eval("\x01") == 993)
  540.                                  {
  541.                                     set("\x01",eval("\x01") - 122);
  542.                                  }
  543.                                  if(eval("\x01") == 885)
  544.                                  {
  545.                                     set("\x01",eval("\x01") + 108);
  546.                                     if(┬º┬ºpop())
  547.                                     {
  548.                                        set("\x01",eval("\x01") - 122);
  549.                                     }
  550.                                  }
  551.                                  else if(eval("\x01") == 731)
  552.                                  {
  553.                                     set("\x01",eval("\x01") + 137);
  554.                                     if(┬º┬ºpop())
  555.                                     {
  556.                                        set("\x01",eval("\x01") - 326);
  557.                                     }
  558.                                  }
  559.                                  else
  560.                                  {
  561.                                     if(eval("\x01") == 871)
  562.                                     {
  563.                                        set("\x01",eval("\x01") - 168);
  564.                                        stop();
  565.                                        this.onEnterFrame = function()
  566.                                        {
  567.                                           if(jalan && !this._parent._parent.pos)
  568.                                           {
  569.                                              fx1 = _X - this._parent._parent.ball._x + _parent._x;
  570.                                              fy1 = _Y - this._parent._parent.ball._y + _parent._y;
  571.                                              var _loc5_ = Math.sqrt(fx1 * fx1 + fy1 * fy1);
  572.                                              fx2 = _X - this._parent._parent.ball1._x + _parent._x;
  573.                                              fy2 = _Y - this._parent._parent.ball1._y + _parent._y;
  574.                                              var _loc4_ = Math.sqrt(fx2 * fx2 + fy2 * fy2);
  575.                                              _X = _X + xspeed;
  576.                                              if(_X + _width / 2 > rightedge)
  577.                                              {
  578.                                                 _X = rightedge - _width / 2;
  579.                                                 xspeed = (- xspeed) * bounce;
  580.                                              }
  581.                                              if(_X - _width / 2 < leftedge)
  582.                                              {
  583.                                                 _X = leftedge + _width / 2;
  584.                                                 xspeed = (- xspeed) * bounce;
  585.                                              }
  586.                                              _Y = _Y + yspeed;
  587.                                              if(_loc5_ <= 30 && !kena && mo._currentframe < 7)
  588.                                              {
  589.                                                 gara = "kena bola";
  590.                                                 kena = true;
  591.                                                 yspeed += this._parent._parent.ball.yspeed / 3;
  592.                                                 xspeed += this._parent._parent.ball.xspeed / 3;
  593.                                                 if(!this._parent._parent.bL)
  594.                                                 {
  595.                                                    this._parent._parent.ball.xspeed = - this._parent._parent.ball.xspeed;
  596.                                                    this._parent._parent.ball.yspeed = - this._parent._parent.ball.yspeed;
  597.                                                 }
  598.                                                 b.play();
  599.                                              }
  600.                                              if(_loc4_ <= 30 && !kena && mo._currentframe < 7)
  601.                                              {
  602.                                                 gara = "kena bola";
  603.                                                 this._parent._parent.nilai += nilai;
  604.                                                 kena = true;
  605.                                                 yspeed += this._parent._parent.ball1.yspeed / 3;
  606.                                                 xspeed += this._parent._parent.ball1.xspeed / 3;
  607.                                                 if(!this._parent._parent.bL)
  608.                                                 {
  609.                                                    this._parent._parent.ball1.xspeed = - this._parent._parent.ball1.xspeed;
  610.                                                    this._parent._parent.ball1.yspeed = - this._parent._parent.ball1.yspeed;
  611.                                                 }
  612.                                                 b.play();
  613.                                              }
  614.                                              if((_loc5_ <= 30 || _loc4_ <= 30) && !kena && mo._currentframe >= 7)
  615.                                              {
  616.                                                 kena = true;
  617.                                                 if(mo._currentframe == 7)
  618.                                                 {
  619.                                                    this._parent._parent.darah += 30;
  620.                                                    gotoAndStop("bon");
  621.                                                 }
  622.                                                 else if(mo._currentframe == 8)
  623.                                                 {
  624.                                                    this._parent._parent._lolos.gotoAndPlay(2);
  625.                                                    gotoAndStop("bon");
  626.                                                 }
  627.                                                 else if(mo._currentframe == 9)
  628.                                                 {
  629.                                                    cx = 0;
  630.                                                    while(cx <= this._parent._parent.daftarmusuh.length)
  631.                                                    {
  632.                                                       dxv = this._parent._parent.daftarmusuh[cx];
  633.                                                       this._parent._parent.stg[dxv].kena = true;
  634.                                                       this._parent._parent.stg[dxv].b.play();
  635.                                                       cx++;
  636.                                                    }
  637.                                                    gotoAndStop("bon");
  638.                                                 }
  639.                                              }
  640.                                              if(kena && pantul)
  641.                                              {
  642.                                                 bx = this._parent._parent.daftarmusuh.length;
  643.                                                 while(bx >= 0)
  644.                                                 {
  645.                                                    tmn = this._parent._parent.daftarmusuh[bx];
  646.                                                    fx3 = _X - _parent[tmn]._x;
  647.                                                    fy3 = _Y - _parent[tmn]._y;
  648.                                                    var _loc3_ = Math.sqrt(fx3 * fx3 + fy3 * fy3);
  649.                                                    if(tar.hitTest(_parent[tmn].tar) && _parent[tmn]._name != _name)
  650.                                                    {
  651.                                                       _parent[tmn].xspeed += xspeed;
  652.                                                       _parent[tmn].yspeed += yspeed;
  653.                                                       _parent[tmn].kena = true;
  654.                                                       _parent[tmn].gara = "ketabrak";
  655.                                                       _parent[tmn].b.play();
  656.                                                       xspeed = - xspeed;
  657.                                                       yspeed = - yspeed;
  658.                                                       _X = _X + xspeed;
  659.                                                       _Y = _Y + yspeed;
  660.                                                       b.gotoAndPlay("duer");
  661.                                                       pantul = false;
  662.                                                    }
  663.                                                    bx--;
  664.                                                 }
  665.                                              }
  666.                                              yspeed = yspeed * drag + gravity;
  667.                                              xspeed *= drag;
  668.                                              if(_Y >= 350 && !kena)
  669.                                              {
  670.                                                 jalan = false;
  671.                                                 if(mo._currentframe >= 7)
  672.                                                 {
  673.                                                    mati();
  674.                                                 }
  675.                                                 else
  676.                                                 {
  677.                                                    this._parent._parent.gempa();
  678.                                                    this._parent._parent.darah -= 10;
  679.                                                    gotoAndStop("masuk");
  680.                                                 }
  681.                                              }
  682.                                           }
  683.                                        };
  684.                                        break;
  685.                                     }
  686.                                     if(eval("\x01") == 278)
  687.                                     {
  688.                                        set("\x01",eval("\x01") - 67);
  689.                                        if(┬º┬ºpop())
  690.                                        {
  691.                                           set("\x01",eval("\x01") + 343);
  692.                                        }
  693.                                     }
  694.                                     else if(eval("\x01") == 554)
  695.                                     {
  696.                                        set("\x01",eval("\x01") + 331);
  697.                                        ┬º┬ºpush(true);
  698.                                     }
  699.                                     else if(eval("\x01") == 269)
  700.                                     {
  701.                                        set("\x01",eval("\x01") + 462);
  702.                                        ┬º┬ºpush(true);
  703.                                     }
  704.                                     else
  705.                                     {
  706.                                        if(eval("\x01") == 228)
  707.                                        {
  708.                                           set("\x01",eval("\x01") + 97);
  709.                                        }
  710.                                        if(eval("\x01") == 325)
  711.                                        {
  712.                                           continue loop0;
  713.                                        }
  714.                                        if(eval("\x01") == 553)
  715.                                        {
  716.                                           set("\x01",eval("\x01") - 325);
  717.                                           if(┬º┬ºpop())
  718.                                           {
  719.                                              set("\x01",eval("\x01") + 97);
  720.                                           }
  721.                                        }
  722.                                        else if(eval("\x01") == 327)
  723.                                        {
  724.                                           set("\x01",eval("\x01") + 358);
  725.                                           if(┬º┬ºpop())
  726.                                           {
  727.                                              set("\x01",eval("\x01") - 416);
  728.                                           }
  729.                                        }
  730.                                        else
  731.                                        {
  732.                                           if(eval("\x01") == 211)
  733.                                           {
  734.                                              set("\x01",eval("\x01") + 343);
  735.                                              ┬º┬ºpush(targetPath(┬º┬ºpop()));
  736.                                              break;
  737.                                           }
  738.                                           if(eval("\x01") == 685)
  739.                                           {
  740.                                              set("\x01",eval("\x01") - 416);
  741.                                           }
  742.                                           if(eval("\x01") == 868)
  743.                                           {
  744.                                              set("\x01",eval("\x01") - 326);
  745.                                           }
  746.                                           if(eval("\x01") != 542)
  747.                                           {
  748.                                              break;
  749.                                           }
  750.                                           set("\x01",eval("\x01") - 264);
  751.                                           ┬º┬ºpush(true);
  752.                                        }
  753.                                     }
  754.                                  }
  755.                               }
  756.                            }
  757.                         }
  758.                      }
  759.                      prevFrame();
  760.                      break loop0;
  761.                   }
  762.                   addr2315:
  763.                }
  764.                else
  765.                {
  766.                   if(eval("\x01") == 892)
  767.                   {
  768.                      set("\x01",eval("\x01") - 305);
  769.                      if(┬º┬ºpop())
  770.                      {
  771.                         set("\x01",eval("\x01") + 241);
  772.                      }
  773.                      continue;
  774.                   }
  775.                   if(eval("\x01") == 289)
  776.                   {
  777.                      set("\x01",eval("\x01") - 97);
  778.                      break loop0;
  779.                   }
  780.                   if(eval("\x01") == 101)
  781.                   {
  782.                      set("\x01",eval("\x01") + 450);
  783.                      if(┬º┬ºpop())
  784.                      {
  785.                         set("\x01",eval("\x01") + 361);
  786.                      }
  787.                      continue;
  788.                   }
  789.                   if(eval("\x01") == 801)
  790.                   {
  791.                      set("\x01",eval("\x01") - 301);
  792.                      this.cacheAsBitmap(true);
  793.                      var sd = _name;
  794.                      var nama = sd.substring(1,2);
  795.                      kena = false;
  796.                      pantul = true;
  797.                      xspeed = 0;
  798.                      yspeed = 0;
  799.                      rightedge = 400;
  800.                      leftedge = 0;
  801.                      topedge = 0;
  802.                      bottomedge = 500;
  803.                      drag = 0.98;
  804.                      bounce = 0.9;
  805.                      nilai = 10;
  806.                      if(nama == 1)
  807.                      {
  808.                         gravity = 0.011;
  809.                      }
  810.                      if(nama == 2)
  811.                      {
  812.                         gravity = 0.013;
  813.                      }
  814.                      if(nama == 3)
  815.                      {
  816.                         gravity = 0.016;
  817.                      }
  818.                      if(nama == 4)
  819.                      {
  820.                         gravity = 0.02;
  821.                      }
  822.                      if(nama == 5)
  823.                      {
  824.                         gravity = 0.023;
  825.                      }
  826.                      if(nama == 6)
  827.                      {
  828.                         gravity = 0.026;
  829.                      }
  830.                      if(this._parent._parent.level == 8)
  831.                      {
  832.                         gravity = 0.026;
  833.                      }
  834.                      if(nama >= 7)
  835.                      {
  836.                         gravity = 0.022;
  837.                      }
  838.                      break loop0;
  839.                   }
  840.                   if(eval("\x01") == 828)
  841.                   {
  842.                      set("\x01",eval("\x01") - 751);
  843.                      ┬º┬ºpush(true);
  844.                      continue;
  845.                   }
  846.                   if(eval("\x01") == 500)
  847.                   {
  848.                      set("\x01",eval("\x01") + 410);
  849.                      ┬º┬ºpush(true);
  850.                      continue;
  851.                   }
  852.                   if(eval("\x01") == 910)
  853.                   {
  854.                      set("\x01",eval("\x01") - 434);
  855.                      if(┬º┬ºpop())
  856.                      {
  857.                         set("\x01",eval("\x01") + 337);
  858.                      }
  859.                      continue;
  860.                   }
  861.                   if(eval("\x01") == 931)
  862.                   {
  863.                      set("\x01",eval("\x01") - 811);
  864.                      ┬º┬ºpush(true);
  865.                      continue;
  866.                   }
  867.                   if(eval("\x01") == 476)
  868.                   {
  869.                      set("\x01",eval("\x01") + 337);
  870.                      break loop0;
  871.                   }
  872.                   if(eval("\x01") == 850)
  873.                   {
  874.                      set("\x01",eval("\x01") - 213);
  875.                      break loop0;
  876.                   }
  877.                   if(eval("\x01") == 912)
  878.                   {
  879.                      set("\x01",eval("\x01") - 822);
  880.                      ┬º┬ºpush(true);
  881.                      continue;
  882.                   }
  883.                   if(eval("\x01") == 120)
  884.                   {
  885.                      set("\x01",eval("\x01") + 739);
  886.                      if(┬º┬ºpop())
  887.                      {
  888.                         set("\x01",eval("\x01") - 619);
  889.                      }
  890.                      continue;
  891.                   }
  892.                   if(eval("\x01") == 393)
  893.                   {
  894.                      set("\x01",eval("\x01") + 457);
  895.                      if(┬º┬ºpop())
  896.                      {
  897.                         set("\x01",eval("\x01") - 213);
  898.                      }
  899.                      continue;
  900.                   }
  901.                   if(eval("\x01") == 77)
  902.                   {
  903.                      set("\x01",eval("\x01") + 724);
  904.                      if(┬º┬ºpop())
  905.                      {
  906.                         set("\x01",eval("\x01") - 301);
  907.                      }
  908.                      continue;
  909.                   }
  910.                   if(eval("\x01") == 90)
  911.                   {
  912.                      set("\x01",eval("\x01") + 199);
  913.                      if(┬º┬ºpop())
  914.                      {
  915.                         set("\x01",eval("\x01") - 97);
  916.                      }
  917.                      continue;
  918.                   }
  919.                   if(eval("\x01") == 240)
  920.                   {
  921.                      set("\x01",eval("\x01") + 114);
  922.                      g = -9;
  923.                      this._parent.bx._x += g;
  924.                      this._parent.bx._y += g;
  925.                      this._parent.stg._x += g;
  926.                      this._parent.stg._y += g;
  927.                      this._parent.by._x += g;
  928.                      this._parent.by._y += g;
  929.                      break loop0;
  930.                   }
  931.                   if(eval("\x01") != 192)
  932.                   {
  933.                      break loop0;
  934.                   }
  935.                   set("\x01",eval("\x01") + 201);
  936.                   ┬º┬ºpush(true);
  937.                }
  938.                ┬º┬ºgoto(addr2601);
  939.             }
  940.          }
  941.       }
  942.       else
  943.       {
  944.          if(eval("\x01") == 654)
  945.          {
  946.             set("\x01",eval("\x01") - 228);
  947.             if(┬º┬ºpop())
  948.             {
  949.                set("\x01",eval("\x01") + 304);
  950.             }
  951.             continue;
  952.          }
  953.          if(eval("\x01") == 903)
  954.          {
  955.             set("\x01",eval("\x01") - 237);
  956.             if(┬º┬ºpop())
  957.             {
  958.                set("\x01",eval("\x01") + 13);
  959.             }
  960.             continue;
  961.          }
  962.          if(eval("\x01") == 230)
  963.          {
  964.             set("\x01",eval("\x01") + 673);
  965.             ┬º┬ºpush(true);
  966.             continue;
  967.          }
  968.          if(eval("\x01") == 904)
  969.          {
  970.             set("\x01",eval("\x01") - 674);
  971.          }
  972.          else
  973.          {
  974.             if(eval("\x01") == 679)
  975.             {
  976.                set("\x01",eval("\x01") - 662);
  977.                ┬º┬ºpush(true);
  978.                continue;
  979.             }
  980.             if(eval("\x01") == 17)
  981.             {
  982.                set("\x01",eval("\x01") + 760);
  983.                if(┬º┬ºpop())
  984.                {
  985.                   set("\x01",eval("\x01") - 59);
  986.                }
  987.                continue;
  988.             }
  989.             if(eval("\x01") == 574)
  990.             {
  991.                set("\x01",eval("\x01") + 325);
  992.                if(┬º┬ºpop())
  993.                {
  994.                   set("\x01",eval("\x01") + 52);
  995.                }
  996.                continue;
  997.             }
  998.             if(eval("\x01") == 777)
  999.             {
  1000.                set("\x01",eval("\x01") - 59);
  1001.             }
  1002.             else
  1003.             {
  1004.                if(eval("\x01") == 718)
  1005.                {
  1006.                   set("\x01",eval("\x01") - 426);
  1007.                   ┬º┬ºpush(true);
  1008.                   continue;
  1009.                }
  1010.                if(eval("\x01") == 292)
  1011.                {
  1012.                   set("\x01",eval("\x01") + 256);
  1013.                   if(┬º┬ºpop())
  1014.                   {
  1015.                      set("\x01",eval("\x01") - 367);
  1016.                   }
  1017.                   continue;
  1018.                }
  1019.                if(eval("\x01") == 548)
  1020.                {
  1021.                   set("\x01",eval("\x01") - 367);
  1022.                   setProperty(┬º┬ºpop(), _X, ┬º┬ºpop());
  1023.                   break;
  1024.                }
  1025.                if(eval("\x01") == 181)
  1026.                {
  1027.                   set("\x01",eval("\x01") + 351);
  1028.                   ┬º┬ºpush(true);
  1029.                   continue;
  1030.                }
  1031.                if(eval("\x01") == 532)
  1032.                {
  1033.                   set("\x01",eval("\x01") + 127);
  1034.                   if(┬º┬ºpop())
  1035.                   {
  1036.                      set("\x01",eval("\x01") - 172);
  1037.                   }
  1038.                   continue;
  1039.                }
  1040.                if(eval("\x01") == 658)
  1041.                {
  1042.                   set("\x01",eval("\x01") - 4);
  1043.                   ┬º┬ºpush(true);
  1044.                   continue;
  1045.                }
  1046.                if(eval("\x01") == 659)
  1047.                {
  1048.                   set("\x01",eval("\x01") - 172);
  1049.                }
  1050.                else
  1051.                {
  1052.                   if(eval("\x01") == 487)
  1053.                   {
  1054.                      set("\x01",eval("\x01") + 87);
  1055.                      ┬º┬ºpush(true);
  1056.                      continue;
  1057.                   }
  1058.                   if(eval("\x01") == 899)
  1059.                   {
  1060.                      set("\x01",eval("\x01") + 52);
  1061.                      prevFrame();
  1062.                      break;
  1063.                   }
  1064.                   if(eval("\x01") == 951)
  1065.                   {
  1066.                      set("\x01",eval("\x01") - 368);
  1067.                      ┬º┬ºpush(true);
  1068.                      continue;
  1069.                   }
  1070.                   if(eval("\x01") == 583)
  1071.                   {
  1072.                      set("\x01",eval("\x01") + 361);
  1073.                      if(┬º┬ºpop())
  1074.                      {
  1075.                         set("\x01",eval("\x01") - 286);
  1076.                      }
  1077.                      continue;
  1078.                   }
  1079.                   if(eval("\x01") != 944)
  1080.                   {
  1081.                      if(eval("\x01") == 426)
  1082.                      {
  1083.                         set("\x01",eval("\x01") + 304);
  1084.                         break;
  1085.                      }
  1086.                      if(eval("\x01") == 730)
  1087.                      {
  1088.                         set("\x01",eval("\x01") - 468);
  1089.                         if(_Y >= 350 && !this._parent.pos)
  1090.                         {
  1091.                            if(this._parent.combo > 1)
  1092.                            {
  1093.                               this._parent.textcombo.play();
  1094.                            }
  1095.                            Mouse.hide();
  1096.                            this.dragging = true;
  1097.                            _X = this._parent.xx = this._parent._xmouse;
  1098.                            _Y = this._parent.yy = this._parent._ymouse;
  1099.                         }
  1100.                         break;
  1101.                      }
  1102.                      break;
  1103.                   }
  1104.                   set("\x01",eval("\x01") - 286);
  1105.                   ┬º┬ºgoto(addr2315);
  1106.                }
  1107.             }
  1108.          }
  1109.          ┬º┬ºgoto(addr553);
  1110.       }
  1111.       ┬º┬ºgoto(addr2315);
  1112.    }
  1113. }
  1114.